home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 429_01 / chess12 / chess_ab.doc < prev    next >
Encoding:
Text File  |  1994-07-20  |  5.2 KB  |  176 lines
  1.                          "Chess for C++, v1.2"
  2.                        by Walter Karas (Cary, NC)
  3.  
  4. [ABSTRACT]
  5.  
  6. The following article presents highlights of "Chess for C++" which is
  7. immediately avialable on CUG volume #432A.  This chess program allows
  8. zero, one, or two computer opponents to play along the game.  This
  9. documentation is based entirely on that provided by Walter Karas for CUG
  10. Library.
  11.  
  12. [PROGRAM USAGE]
  13.  
  14.         CHESS white-player black-player
  15.  
  16. A player (white or black) is specified as one of "U", "C1", "C2" or
  17. "C3".  "U" specifies that the player's moves will be selected by the
  18. user.  "C1", "C2" or "C3" specifies that the player's moves will be
  19. selected by the computer.  The digit (1, 2 or 3) gives the relative
  20. skill level with which the computer selects the player's moves.  For
  21. example, the command:
  22.  
  23.         CHESS C2 U
  24.  
  25. starts a game with the computer selecting the white player's moves (at
  26. skill level 2) and the user selecting the black player's moves.  The
  27. default for black-player is C2, and the default for white-player is U.
  28. It is legal for both players to be user-controlled, or for both players
  29. to be computer-controlled.  When playing at skill level 3, the computer
  30. will take several minutes to select each move.
  31.  
  32. Pieces on the chess board are represented by two letter strings.  The
  33. first letter is W (for a white piece) or B (for a black piece).  Here
  34. is the legend for the second letter:
  35.  
  36. P - Pawn
  37. R - Rook
  38. N - Knight
  39. B - Bishop
  40. Q - Queen
  41. K - King
  42.  
  43. [IMPLEMENTATION]
  44.  
  45. The following files contain the source code for the program:
  46.  
  47.     brdsize.hpp
  48.     charui.cpp
  49.     charui.hpp
  50.     chcharui.cpp
  51.     chcharui.hpp
  52.     chess.cpp
  53.     chess.hpp
  54.     chessui.cpp
  55.     chessui.hpp
  56.     cplayer.cpp
  57.     cplayer.hpp
  58.     main.cpp
  59.     misc.hpp
  60.     player.hpp
  61.     uplayer.cpp
  62.     uplayer.hpp
  63.  
  64. Here are the important class hierarchies:
  65.  
  66.                    PIECE
  67.                      *
  68.                      *
  69.     ************************************
  70.     *      *      *       *      *     *
  71.     *      *      *       *      *     *
  72.    KING  QUEEN  BISHOP  KNIGHT  ROOK  PAWN
  73.  
  74.  
  75.               PLAYER
  76.                 *
  77.           **************
  78.           *            *
  79.           *            *
  80.    COMPUTERPLAYER  USERPLAYER
  81.  
  82.  
  83.       CHARUSERIFACE
  84.             *
  85.             *
  86.     CHESSCHARUSERIFACE
  87.             *
  88.             *
  89.       CHESSUSERIFACE
  90.  
  91.  
  92. This program uses BIOS calls to interface with the screen and
  93. keyboard.  It could be ported to another character-oriented API by
  94. changing the implementation of CHARUSERIFACE.  It could be ported to a
  95. GUI API by changing the implementation of CHESSUSERIFACE.
  96.  
  97. [ALGORITHM FOR COMPUTER PLAYER]
  98.  
  99. The algorithm for the computer player appears in the play() member
  100. function of COMPUTERPLAYER as shown below:
  101.  
  102. GAMESTATUS COMPUTERPLAYER::play(BOARD &board) const
  103.   {
  104.     BOARDMETRIC metric;
  105.     BESTMOVES bestMoves;
  106.     int best;
  107.  
  108.     ChessUI.thinkingMessage(whatColor());
  109.     board.findBestMoves(lookAhead, whatColor(), metric, &bestMoves);
  110.     if (metric.kingSituation[whatColor()] != KINGOK)
  111.       {
  112.         // see if checkmate/stalemate current or predicted
  113.         if (lookAhead > 2)
  114.           board.findBestMoves(2, whatColor(), metric, &bestMoves);
  115.  
  116.         if (metric.kingSituation[whatColor()] == KINGLOST)
  117.           {
  118.             ChessUI.clearMessage();
  119.             ChessUI.mated(whatColor());
  120.             return(GAMEOVER);
  121.           }
  122.         else if (metric.kingSituation[whatColor()] == STALEMATE)
  123.           {
  124.             ChessUI.clearMessage();
  125.             ChessUI.staleMated(whatColor());
  126.             return(GAMEOVER);
  127.           }
  128.       }
  129.  
  130.     best = bestDevelopMove(board, whatColor(), bestMoves);
  131.  
  132.     if (!ChessUI.computerMove(board, whatColor(),
  133.                               bestMoves.move[best]))
  134.         return(GAMEOVER);
  135.  
  136.     return(GAMECONTINUE);
  137.   }
  138.  
  139.  
  140. The first step is to find the list of possible moves which are predicted
  141. to get the opponent in checkmate, or provide the most material gain (or
  142. minimize material loss).  This prediction is done by looking ahead
  143. several moves.  The number of moves of look-ahead is 2 for skill level
  144. 1, 3 for skill level 2, and 4 for skill level 3. The look-ahead is
  145. performed by the recursive findBestMove() member function of the BOARD
  146. class.  To select among the list of best moves, a "coverage/threat"
  147. metric is used.  This metric measures how much of the board will be
  148. "attackable" after the move, giving extra points for blocking moves by
  149. the opponent's king.  It also encourages moving pieces closer to the
  150. opponent king.
  151.  
  152. Please send all comments and bug reports to:
  153.  
  154. Walt Karas
  155. 118 Barcelona Ct.
  156. Cary, NC 27513
  157.  
  158. This program is no Deep Thought, and can easily be beaten by a good
  159. human player.
  160.  
  161. [VERSION INFORMATION]
  162.  
  163. Version 1.0
  164. o  Initial release.
  165.  
  166. Version 1.1
  167. o  Removal of obscure bug in Computer Player play() member function.
  168. o  Fine tuning of best development metric.
  169. o  Removal of useless "usage" printing code.
  170. o  Removal of bug with en passant move logic which caused pawns to
  171.    "disappear" from internal representation of board, although they
  172.    were still on the screen.
  173.  
  174. Version 1.2
  175. o  Small changes, essentially cosmetic in nature.
  176.